package com.cms.recursoshumanos.container;

import com.cms.recursoshumanos.constant.Constant;
import com.cms.recursoshumanos.object.ArticuloCarrito;

import net.rim.device.api.system.Characters;
import net.rim.device.api.ui.Color;
import net.rim.device.api.ui.Field;
import net.rim.device.api.ui.Graphics;
import net.rim.device.api.ui.Manager;
import net.rim.device.api.ui.component.Menu;

public class LinedGridFieldManager extends Manager 
{
	private int[] columnWidths;
	private int columns;
	private int allRowHeight = -1;
	int rowHeight=-1;
	private boolean _isFocus;
	protected int _drawPosition = -1;
	private ArticuloCarrito elArticuloCarrito;
		
	
	/**
	 * Constructs a new GridFieldManager with the specified number of columns.
	 * Rows will be added as needed to display fields.
	 * Fields will be added to the grid in the order they are added to this manager,
	 * filling up each row left-to-right:
	 *
	 * For example a 2 column manager:
	 *
	 * [Field1][Field2]
	 * [Field3][Field4]
	 * [Field5]
	 *
	 * There are two constructors available: 
	 * In the first, 
	 * Column widths are all equal, and the manager will attempt to use all available width.
	 * The height of each row will be equal to the height of the tallest Field in that row.
	 * Field positional styles are respected, so fields that are smaller than the row/column
	 * they are in can be positioned left, right, top bottom, or centered.  They default to top left.
	 *
	 * @param columns Number of columns in the grid
	 * @param style
	 * 
	 * 
	 * @author modified 2010 by Arjun Dhar<br />
	 * @author modified 2009 by TBC Software http://www.vocshop.com
	 * @author Copyright 2008 by Anthony Rizk - http://www.thinkingblackberry.com
	 */
	public LinedGridFieldManager ( int columns, long style ) {
		super ( style );
		this.columns = columns;
	}
	/*
	 * In the second constructor, instead of passing a single int with the number  of columns, 
	 * an array of ints is passed with the width (in pixels) of each column.  The grid will be 
	 * constructed with as many columns as required to comply with the array, and the total width 
	 * of the grid __MAY__ be wider than the screen.   If so, the grid needs to be contained within 
	 * a horizontally scrolling screen or manager.
	 */

	public LinedGridFieldManager ( int[] columnWidths, long style, ArticuloCarrito elArticulo ) {
		super ( style );
		this.elArticuloCarrito = elArticulo;
		this.columnWidths = columnWidths;
		this.columns = columnWidths.length;
	}

	public LinedGridFieldManager ( int[] columnWidths, int rowHeight, long style, ArticuloCarrito elArticuloCarrito ) {
		this ( columnWidths, style , elArticuloCarrito );
		this.allRowHeight  = rowHeight;
	}

	public ArticuloCarrito getArticuloCarrito()
	{
		return this.elArticuloCarrito;
	}
	//jk Override to eliminate menu choices
	//by default, we preffer to explicitly create menus rather than let the default 
	// blackberry menus come through.  Change this as you will.
	protected void onFocus(int direction) 
	{
	    super.onFocus(direction);
	    _isFocus = true;
	    invalidate();
	}
	protected void onUnfocus() 
	{
	    super.onUnfocus();
	    _isFocus = false;
	    invalidate();
	}
	public void setDrawPosition( int drawPosition )
	{
		_drawPosition = drawPosition;
	}
	protected void drawFocus( Graphics g, boolean on )
	{
		if( _drawPosition < 0 ) {
			super.drawFocus( g, on );
		} 
		else 
		{
			boolean oldDrawStyleFocus = g.isDrawingStyleSet( Graphics.DRAWSTYLE_FOCUS );
			try 
			{
				if( on ) 
				{
					g.setDrawingStyle( Graphics.DRAWSTYLE_FOCUS, true );
				}
				paintBackground( g );
				paint( g );
			} 
			finally 
			{
				g.setDrawingStyle( Graphics.DRAWSTYLE_FOCUS, oldDrawStyleFocus );
			}
		}
	}
	  
	protected boolean keyChar( char character, int status, int time ) 
	{
		if( character == Characters.ENTER ) 
		{
			clickButton();
			return true;
		}
		return super.keyChar( character, status, time );
	}
	  
	protected boolean navigationClick( int status, int time ) 
	{
		clickButton(); 
		return true;    
	}
	  
	protected boolean trackwheelClick( int status, int time )
	{        
		clickButton();    
		return true;
	}
	  
	  //#ifndef VER_4.1.0 | 4.0.0
	protected boolean invokeAction( int action ) 
	{
		switch( action ) 
		{
			case ACTION_INVOKE: 
			{
				clickButton(); 
				return true;
			}
		}
		return super.invokeAction( action );
	}
	  //#endif        
	       
	  /**
	   * A public way to click this button
	   */
	public void clickButton() 
	{
		fieldChangeNotify( 0 );
	}
	
	public void makeMenu ( Menu menu, int instance ) {
	}

	/*protected boolean navigationMovement ( int dx, int dy, int status, int time ) {

		int focusIndex = getFieldWithFocusIndex();

		/*
		 * in each while, after we have moved into the new field, update the display at top of screen
		 * right side of a row wraps to that row's left.  Top wraps to the bottom,  bottom wraps to the 
		 * top.  The default blackberry movement of "spiral down" using the right arrow or trackwheel 
		 * is overridden. */
/*
		int lnFieldCount = getFieldCount();
		while ( dy > 0 ) {
			focusIndex += columns;

			if ( focusIndex >= lnFieldCount ) {
				if (lnFieldCount > 0) {
					//Wrap around to top row
					//getField(f)
					getField(lnFieldCount-1).setFocus();
					return true;
				} else {
					return false; // Focus moves out of this manager
				}
			} else {
				Field f = getField ( focusIndex );

				if ( f.isFocusable() ) { // Only move the focus onto focusable fields
					f.setFocus();
					dy--;
					//UpdateDisplay();
				}
			}
		}

		while ( dy < 0 ) {
			focusIndex -= columns;

			if ( focusIndex < 0 ) {
				//Wrap around to bottom row
				getField(0).setFocus();
				return true;
			} else {
				Field f = getField ( focusIndex );

				if ( f.isFocusable() ) {
					f.setFocus();
					dy++;
					//UpdateDisplay();
				}
			}
		}

		while ( dx > 0 ) {
			if (focusIndex == lnFieldCount-1) {
				return false;
			}
			if ((focusIndex+1)%columns == 0) {
				//Wrap around to beginning of line or boundary
				//focusIndex = (focusIndex-columns) + 1;
				return false;
			} else {
				focusIndex ++;
			}

			if ( focusIndex >= lnFieldCount ) {
				if (lnFieldCount > 0) {
					getField(1).setFocus();
					return true;
				} else {
					return false; // Focus moves out of this manager
				}
			} else {
				Field f = getField ( focusIndex );

				if ( f.isFocusable() ) {
					f.setFocus();
					dx--;
					// UpdateDisplay();
				}
			}
		}

		while ( dx < 0 ) {
			if (focusIndex%columns == 0) {
				//Wrap around to end of line Or Boundary
				//focusIndex = (focusIndex+columns) -1;
				return false;
			} else {
				focusIndex --;
			}


			if ( focusIndex < 0 ) {
				return false;
			} else {
				Field f = getField ( focusIndex );

				if ( f.isFocusable() ) {
					f.setFocus();
					dx++;
					//   UpdateDisplay();
				}
			}
		}

		return true;
	}*/

	protected void sublayout ( int width, int height ) {
		int y = 0;

		if ( columnWidths == null ) {
			columnWidths = new int[columns];

			for ( int i = 0; i < columns; i++ ) {
				columnWidths[i] = width / columns;
			}
		}

		Field[] fields = new Field[columnWidths.length];
		int currentColumn = 0;
		int rowHeight = 0;

		for ( int i = 0; i < getFieldCount(); i++ ) {
			fields[currentColumn] = getField ( i );
			layoutChild ( fields[currentColumn], columnWidths[currentColumn], height - y );

			if ( fields[currentColumn].getHeight() > rowHeight ) {
				rowHeight = fields[currentColumn].getHeight();
			}

			currentColumn++;

			if ( currentColumn == columnWidths.length || i == getFieldCount() - 1 ) {
				int x = 0;

				if ( this.allRowHeight >= 0 ) {
					rowHeight = this.allRowHeight;
				}
				
				

				for ( int c = 0; c < currentColumn; c++ ) {
					long fieldStyle = fields[c].getStyle();
					int fieldXOffset = 0;
					long fieldHalign = fieldStyle & Field.FIELD_HALIGN_MASK;

					if ( fieldHalign == Field.FIELD_RIGHT ) {
						fieldXOffset = columnWidths[c] - fields[c].getWidth();
					} else if ( fieldHalign == Field.FIELD_HCENTER ) {
						fieldXOffset = ( columnWidths[c] - fields[c].getWidth() ) / 2;
					}

					int fieldYOffset = 0;
					long fieldValign = fieldStyle & Field.FIELD_VALIGN_MASK;

					if ( fieldValign == Field.FIELD_BOTTOM ) {
						fieldYOffset = rowHeight - fields[c].getHeight();
					} else if ( fieldValign == Field.FIELD_VCENTER ) {
						fieldYOffset = ( rowHeight - fields[c].getHeight() ) / 2;
					}

					setPositionChild ( fields[c], x + fieldXOffset, y + fieldYOffset );
					x += columnWidths[c];
				}

				currentColumn = 0;
				y += rowHeight;
			}

			if ( y >= height ) {
				break;
			}
		}

		int totalWidth = 0;

		for ( int i = 0; i < columnWidths.length; i++ ) {
			totalWidth += columnWidths[i];
		}

		this.rowHeight=allRowHeight;
		if(this.rowHeight<=0)
			this.rowHeight=rowHeight;
		setExtent ( totalWidth, Math.min ( y, height ) );
	}
	
	protected void paint(Graphics g) {
		// TODO Auto-generated method stub
		if (_isFocus)
	    {
			g.setBackgroundColor(Constant.COLOR_FOCUS_NORMAL);	
	    }
	    else
	    {
	    	g.setBackgroundColor(Constant.COLOR_UNFOCUS_NORMAL);
	    }
	    g.clear();
		super.paint(g);
		g.setColor(Color.BLACK);
		int y=0;
		for(int i=0;i<getFieldCount();i++)
		{
			int x=0;
			for(int j=0;j<columnWidths.length;j++)
			{
				g.drawLine(x-1, 0, x-1, getHeight());
				x+=columnWidths[j];
			}
			y+=rowHeight;
			g.drawLine(0, y-1, getWidth(), y-1);
			
		}
		
	    
	}

}
